/**
 * TodoData 类 - 任务数据管理
 * 提供任务的CRUD操作和本地存储功能
 */
class TodoData {
    constructor() {
        // 数据存储键名
        this.NORMAL_TASKS_KEY = 'boringtodo_normal_tasks';
        this.COMPLETED_TASKS_KEY = 'boringtodo_completed_tasks';
        this.SETTINGS_KEY = 'boringtodo_settings';
        
        // 初始化数据
        this.normalTasks = this.loadFromStorage(this.NORMAL_TASKS_KEY) || [];
        this.completedTasks = this.loadFromStorage(this.COMPLETED_TASKS_KEY) || [];
        this.settings = this.loadSettings();
        
        // 确保数据完整性
        this.initializeData();
    }
    
    /**
     * 初始化数据，确保所有必要的字段都存在
     */
    initializeData() {
        // 确保每个任务都有正确的属性
        this.normalTasks = this.normalTasks.map(task => this.ensureTaskProperties(task));
        this.completedTasks = this.completedTasks.map(task => this.ensureTaskProperties(task));
        
        // 按照创建时间排序
        this.normalTasks.sort((a, b) => new Date(b.creationDate) - new Date(a.creationDate));
        this.completedTasks.sort((a, b) => new Date(b.completionDate) - new Date(a.completionDate));
        
        // 保存数据以确保格式正确
        this.saveAllData();
    }
    
    /**
     * 确保任务对象具有所有必要的属性
     * @param {Object} task 任务对象
     * @returns {Object} 带有所有必要属性的任务对象
     */
    ensureTaskProperties(task) {
        return {
            id: task.id || this.generateId(),
            description: task.description || '',
            notes: task.notes || '',
            creationDate: task.creationDate || new Date().toISOString(),
            expectedCompletionDate: task.expectedCompletionDate || null,
            completionDate: task.completionDate || null,
            isCompleted: !!task.completionDate
        };
    }
    
    /**
     * 生成唯一ID
     * @returns {string} 唯一ID
     */
    generateId() {
        return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
    }
    
    /**
     * 从localStorage加载数据
     * @param {string} key 存储键名
     * @returns {Array|Object|null} 加载的数据或null
     */
    loadFromStorage(key) {
        try {
            const data = localStorage.getItem(key);
            return data ? JSON.parse(data) : null;
        } catch (error) {
            console.error(`加载数据失败: ${error.message}`);
            return null;
        }
    }
    
    /**
     * 将数据保存到localStorage
     * @param {string} key 存储键名
     * @param {Array|Object} data 要保存的数据
     */
    saveToStorage(key, data) {
        try {
            localStorage.setItem(key, JSON.stringify(data));
        } catch (error) {
            console.error(`保存数据失败: ${error.message}`);
        }
    }
    
    /**
     * 保存所有数据到localStorage
     */
    saveAllData() {
        this.saveToStorage(this.NORMAL_TASKS_KEY, this.normalTasks);
        this.saveToStorage(this.COMPLETED_TASKS_KEY, this.completedTasks);
        this.saveToStorage(this.SETTINGS_KEY, this.settings);
    }
    
    /**
     * 加载应用设置
     * @returns {Object} 应用设置
     */
    loadSettings() {
        const defaultSettings = {
            enableAutoScreenshot: false,
            screenshotIntervalMinutes: 60,
            reportPrompt: '请根据以下完成的任务，总结一下我的工作内容，用第一人称：'
        };
        
        const savedSettings = this.loadFromStorage(this.SETTINGS_KEY);
        return savedSettings ? {...defaultSettings, ...savedSettings} : defaultSettings;
    }
    
    /**
     * 保存应用设置
     * @param {Object} newSettings 新的设置
     */
    saveSettings(newSettings) {
        this.settings = {...this.settings, ...newSettings};
        this.saveToStorage(this.SETTINGS_KEY, this.settings);
    }
    
    /**
     * 获取所有普通任务
     * @returns {Array} 普通任务列表
     */
    getNormalTasks() {
        return [...this.normalTasks];
    }
    
    /**
     * 获取所有已完成任务
     * @returns {Array} 已完成任务列表
     */
    getCompletedTasks() {
        return [...this.completedTasks];
    }
    
    /**
     * 通过ID获取任务
     * @param {string} id 任务ID
     * @returns {Object|null} 找到的任务或null
     */
    getTaskById(id) {
        const task = this.normalTasks.find(t => t.id === id) || 
                     this.completedTasks.find(t => t.id === id);
        return task ? {...task} : null;
    }
    
    /**
     * 添加新任务
     * @param {Object} taskData 任务数据
     * @returns {Object} 新创建的任务
     */
    addTask(taskData) {
        const newTask = this.ensureTaskProperties({
            ...taskData,
            creationDate: new Date().toISOString()
        });
        
        this.normalTasks.unshift(newTask);
        this.saveToStorage(this.NORMAL_TASKS_KEY, this.normalTasks);
        
        return {...newTask};
    }
    
    /**
     * 更新任务
     * @param {string} id 要更新的任务ID
     * @param {Object} taskData 更新的数据
     * @returns {Object|null} 更新后的任务或null
     */
    updateTask(id, taskData) {
        // 判断任务在哪个列表
        let taskList = this.normalTasks.find(t => t.id === id) ? 
                      'normalTasks' : 'completedTasks';
                      
        // 查找并更新任务
        const index = this[taskList].findIndex(t => t.id === id);
        if (index === -1) return null;
        
        const updatedTask = {
            ...this[taskList][index],
            ...taskData
        };
        
        // 如果完成状态改变，需要移动任务
        if (!this[taskList][index].completionDate && updatedTask.completionDate) {
            // 从普通任务移到已完成任务
            this.normalTasks = this.normalTasks.filter(t => t.id !== id);
            updatedTask.isCompleted = true;
            this.completedTasks.unshift(updatedTask);
            this.saveToStorage(this.NORMAL_TASKS_KEY, this.normalTasks);
            this.saveToStorage(this.COMPLETED_TASKS_KEY, this.completedTasks);
        } else if (this[taskList][index].completionDate && !updatedTask.completionDate) {
            // 从已完成任务移回普通任务
            this.completedTasks = this.completedTasks.filter(t => t.id !== id);
            updatedTask.isCompleted = false;
            this.normalTasks.unshift(updatedTask);
            this.saveToStorage(this.NORMAL_TASKS_KEY, this.normalTasks);
            this.saveToStorage(this.COMPLETED_TASKS_KEY, this.completedTasks);
        } else {
            // 只更新属性
            this[taskList][index] = updatedTask;
            this.saveToStorage(taskList === 'normalTasks' ? 
                              this.NORMAL_TASKS_KEY : this.COMPLETED_TASKS_KEY, 
                              this[taskList]);
        }
        
        return {...updatedTask};
    }
    
    /**
     * 删除任务
     * @param {string} id 要删除的任务ID
     * @returns {boolean} 是否成功删除
     */
    deleteTask(id) {
        // 判断任务在哪个列表
        let taskList = this.normalTasks.find(t => t.id === id) ? 
                      'normalTasks' : 'completedTasks';
                      
        const originalLength = this[taskList].length;
        this[taskList] = this[taskList].filter(t => t.id !== id);
        
        // 保存更改
        this.saveToStorage(taskList === 'normalTasks' ? 
                          this.NORMAL_TASKS_KEY : this.COMPLETED_TASKS_KEY, 
                          this[taskList]);
                          
        return this[taskList].length < originalLength;
    }
    
    /**
     * 将任务标记为已完成
     * @param {string} id 任务ID
     * @returns {Object|null} 更新后的任务或null
     */
    markTaskAsComplete(id) {
        const task = this.normalTasks.find(t => t.id === id);
        if (!task) return null;
        
        return this.updateTask(id, {
            completionDate: new Date().toISOString(),
            isCompleted: true
        });
    }
    
    /**
     * 将任务移至列表顶部
     * @param {string} id 任务ID
     * @returns {boolean} 是否成功移动
     */
    moveTaskToTop(id) {
        // 判断任务在哪个列表
        let taskList = this.normalTasks.find(t => t.id === id) ? 
                      'normalTasks' : 'completedTasks';
                      
        const index = this[taskList].findIndex(t => t.id === id);
        if (index === -1) return false;
        
        // 移除任务并添加到顶部
        const task = this[taskList][index];
        this[taskList].splice(index, 1);
        this[taskList].unshift(task);
        
        // 保存更改
        this.saveToStorage(taskList === 'normalTasks' ? 
                          this.NORMAL_TASKS_KEY : this.COMPLETED_TASKS_KEY, 
                          this[taskList]);
                          
        return true;
    }
    
    /**
     * 导出任务数据为JSON
     * @returns {string} JSON格式的任务数据
     */
    exportData() {
        return JSON.stringify({
            normalTasks: this.normalTasks,
            completedTasks: this.completedTasks,
            settings: this.settings,
            exportDate: new Date().toISOString()
        });
    }
    
    /**
     * 导入任务数据
     * @param {string} jsonData JSON格式的任务数据
     * @returns {boolean} 是否成功导入
     */
    importData(jsonData) {
        try {
            const data = JSON.parse(jsonData);
            
            if (data.normalTasks && Array.isArray(data.normalTasks)) {
                this.normalTasks = data.normalTasks.map(task => this.ensureTaskProperties(task));
            }
            
            if (data.completedTasks && Array.isArray(data.completedTasks)) {
                this.completedTasks = data.completedTasks.map(task => this.ensureTaskProperties(task));
            }
            
            if (data.settings && typeof data.settings === 'object') {
                this.settings = {...this.loadSettings(), ...data.settings};
            }
            
            this.saveAllData();
            return true;
        } catch (error) {
            console.error(`导入数据失败: ${error.message}`);
            return false;
        }
    }
    
    /**
     * 筛选指定时间范围内完成的任务
     * @param {number} days 天数范围，负数表示过去的天数
     * @returns {Array} 符合条件的任务列表
     */
    getCompletedTasksInRange(days) {
        const thresholdDate = new Date();
        thresholdDate.setDate(thresholdDate.getDate() + days);
        
        return this.completedTasks.filter(task => 
            task.completionDate && new Date(task.completionDate) >= thresholdDate
        );
    }
}

// 创建全局数据实例
const todoData = new TodoData(); 